// Copyright 2025 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Code generated by sidekick. DO NOT EDIT.

#![allow(rustdoc::redundant_explicit_links)]
#![allow(rustdoc::broken_intra_doc_links)]
#![no_implicit_prelude]
extern crate bytes;
extern crate serde;
extern crate serde_json;
extern crate serde_with;
extern crate std;
extern crate wkt;

mod debug;
mod deserialize;
mod serialize;

/// Defines a Cloud Organization `Policy` which is used to specify `Constraints`
/// for configurations of Cloud Platform resources.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Policy {
    /// Version of the `Policy`. Default version is 0;
    pub version: i32,

    /// The name of the `Constraint` the `Policy` is configuring, for example,
    /// `constraints/serviceuser.services`.
    ///
    /// Immutable after creation.
    pub constraint: std::string::String,

    /// An opaque tag indicating the current version of the `Policy`, used for
    /// concurrency control.
    ///
    /// When the `Policy` is returned from either a `GetPolicy` or a
    /// `ListOrgPolicy` request, this `etag` indicates the version of the current
    /// `Policy` to use when executing a read-modify-write loop.
    ///
    /// When the `Policy` is returned from a `GetEffectivePolicy` request, the
    /// `etag` will be unset.
    ///
    /// When the `Policy` is used in a `SetOrgPolicy` method, use the `etag` value
    /// that was returned from a `GetOrgPolicy` request as part of a
    /// read-modify-write loop for concurrency control. Not setting the `etag`in a
    /// `SetOrgPolicy` request will result in an unconditional write of the
    /// `Policy`.
    pub etag: ::bytes::Bytes,

    /// The time stamp the `Policy` was previously updated. This is set by the
    /// server, not specified by the caller, and represents the last time a call to
    /// `SetOrgPolicy` was made for that `Policy`. Any value set by the client will
    /// be ignored.
    pub update_time: std::option::Option<wkt::Timestamp>,

    /// The field to populate is based on the `constraint_type` value in the
    /// `Constraint`.
    /// `list_constraint` => `list_policy`
    /// `boolean_constraint` => `boolean_policy`
    ///
    /// A `restore_default` message may be used with any `Constraint` type.
    ///
    /// Providing a *_policy that is incompatible with the `constraint_type` will
    /// result in an `invalid_argument` error.
    ///
    /// Attempting to set a `Policy` with a `policy_type` not set will result in an
    /// `invalid_argument` error.
    pub policy_type: std::option::Option<crate::model::policy::PolicyType>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl Policy {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [version][crate::model::Policy::version].
    pub fn set_version<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.version = v.into();
        self
    }

    /// Sets the value of [constraint][crate::model::Policy::constraint].
    pub fn set_constraint<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.constraint = v.into();
        self
    }

    /// Sets the value of [etag][crate::model::Policy::etag].
    pub fn set_etag<T: std::convert::Into<::bytes::Bytes>>(mut self, v: T) -> Self {
        self.etag = v.into();
        self
    }

    /// Sets the value of [update_time][crate::model::Policy::update_time].
    pub fn set_update_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.update_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [update_time][crate::model::Policy::update_time].
    pub fn set_or_clear_update_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.update_time = v.map(|x| x.into());
        self
    }

    /// Sets the value of [policy_type][crate::model::Policy::policy_type].
    ///
    /// Note that all the setters affecting `policy_type` are mutually
    /// exclusive.
    pub fn set_policy_type<
        T: std::convert::Into<std::option::Option<crate::model::policy::PolicyType>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.policy_type = v.into();
        self
    }

    /// The value of [policy_type][crate::model::Policy::policy_type]
    /// if it holds a `ListPolicy`, `None` if the field is not set or
    /// holds a different branch.
    pub fn list_policy(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::policy::ListPolicy>> {
        #[allow(unreachable_patterns)]
        self.policy_type.as_ref().and_then(|v| match v {
            crate::model::policy::PolicyType::ListPolicy(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [policy_type][crate::model::Policy::policy_type]
    /// to hold a `ListPolicy`.
    ///
    /// Note that all the setters affecting `policy_type` are
    /// mutually exclusive.
    pub fn set_list_policy<
        T: std::convert::Into<std::boxed::Box<crate::model::policy::ListPolicy>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.policy_type =
            std::option::Option::Some(crate::model::policy::PolicyType::ListPolicy(v.into()));
        self
    }

    /// The value of [policy_type][crate::model::Policy::policy_type]
    /// if it holds a `BooleanPolicy`, `None` if the field is not set or
    /// holds a different branch.
    pub fn boolean_policy(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::policy::BooleanPolicy>> {
        #[allow(unreachable_patterns)]
        self.policy_type.as_ref().and_then(|v| match v {
            crate::model::policy::PolicyType::BooleanPolicy(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [policy_type][crate::model::Policy::policy_type]
    /// to hold a `BooleanPolicy`.
    ///
    /// Note that all the setters affecting `policy_type` are
    /// mutually exclusive.
    pub fn set_boolean_policy<
        T: std::convert::Into<std::boxed::Box<crate::model::policy::BooleanPolicy>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.policy_type =
            std::option::Option::Some(crate::model::policy::PolicyType::BooleanPolicy(v.into()));
        self
    }

    /// The value of [policy_type][crate::model::Policy::policy_type]
    /// if it holds a `RestoreDefault`, `None` if the field is not set or
    /// holds a different branch.
    pub fn restore_default(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::policy::RestoreDefault>> {
        #[allow(unreachable_patterns)]
        self.policy_type.as_ref().and_then(|v| match v {
            crate::model::policy::PolicyType::RestoreDefault(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [policy_type][crate::model::Policy::policy_type]
    /// to hold a `RestoreDefault`.
    ///
    /// Note that all the setters affecting `policy_type` are
    /// mutually exclusive.
    pub fn set_restore_default<
        T: std::convert::Into<std::boxed::Box<crate::model::policy::RestoreDefault>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.policy_type =
            std::option::Option::Some(crate::model::policy::PolicyType::RestoreDefault(v.into()));
        self
    }
}

impl wkt::message::Message for Policy {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.orgpolicy.v1.Policy"
    }
}

/// Defines additional types related to [Policy].
pub mod policy {
    #[allow(unused_imports)]
    use super::*;

    /// Used in `policy_type` to specify how `list_policy` behaves at this
    /// resource.
    ///
    /// `ListPolicy` can define specific values and subtrees of Cloud Resource
    /// Manager resource hierarchy (`Organizations`, `Folders`, `Projects`) that
    /// are allowed or denied by setting the `allowed_values` and `denied_values`
    /// fields. This is achieved by using the `under:` and optional `is:` prefixes.
    /// The `under:` prefix is used to denote resource subtree values.
    /// The `is:` prefix is used to denote specific values, and is required only
    /// if the value contains a ":". Values prefixed with "is:" are treated the
    /// same as values with no prefix.
    ///
    /// Ancestry subtrees must be in one of the following formats:
    /// - "projects/\<project-id\>", e.g. "projects/tokyo-rain-123"
    /// - "folders/\<folder-id\>", e.g. "folders/1234"
    /// - "organizations/\<organization-id\>", e.g. "organizations/1234"
    ///
    /// The `supports_under` field of the associated `Constraint`  defines whether
    /// ancestry prefixes can be used. You can set `allowed_values` and
    /// `denied_values` in the same `Policy` if `all_values` is
    /// `ALL_VALUES_UNSPECIFIED`. `ALLOW` or `DENY` are used to allow or deny all
    /// values. If `all_values` is set to either `ALLOW` or `DENY`,
    /// `allowed_values` and `denied_values` must be unset.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct ListPolicy {
        /// List of values allowed  at this resource. Can only be set if `all_values`
        /// is set to `ALL_VALUES_UNSPECIFIED`.
        pub allowed_values: std::vec::Vec<std::string::String>,

        /// List of values denied at this resource. Can only be set if `all_values`
        /// is set to `ALL_VALUES_UNSPECIFIED`.
        pub denied_values: std::vec::Vec<std::string::String>,

        /// The policy all_values state.
        pub all_values: crate::model::policy::list_policy::AllValues,

        /// Optional. The Google Cloud Console will try to default to a configuration
        /// that matches the value specified in this `Policy`. If `suggested_value`
        /// is not set, it will inherit the value specified higher in the hierarchy,
        /// unless `inherit_from_parent` is `false`.
        pub suggested_value: std::string::String,

        /// Determines the inheritance behavior for this `Policy`.
        ///
        /// By default, a `ListPolicy` set at a resource supercedes any `Policy` set
        /// anywhere up the resource hierarchy. However, if `inherit_from_parent` is
        /// set to `true`, then the values from the effective `Policy` of the parent
        /// resource are inherited, meaning the values set in this `Policy` are
        /// added to the values inherited up the hierarchy.
        ///
        /// Setting `Policy` hierarchies that inherit both allowed values and denied
        /// values isn't recommended in most circumstances to keep the configuration
        /// simple and understandable. However, it is possible to set a `Policy` with
        /// `allowed_values` set that inherits a `Policy` with `denied_values` set.
        /// In this case, the values that are allowed must be in `allowed_values` and
        /// not present in `denied_values`.
        ///
        /// For example, suppose you have a `Constraint`
        /// `constraints/serviceuser.services`, which has a `constraint_type` of
        /// `list_constraint`, and with `constraint_default` set to `ALLOW`.
        /// Suppose that at the Organization level, a `Policy` is applied that
        /// restricts the allowed API activations to {`E1`, `E2`}. Then, if a
        /// `Policy` is applied to a project below the Organization that has
        /// `inherit_from_parent` set to `false` and field all_values set to DENY,
        /// then an attempt to activate any API will be denied.
        ///
        /// The following examples demonstrate different possible layerings for
        /// `projects/bar` parented by `organizations/foo`:
        ///
        /// Example 1 (no inherited values):
        /// `organizations/foo` has a `Policy` with values:
        /// {allowed_values: "E1" allowed_values:"E2"}
        /// `projects/bar` has `inherit_from_parent` `false` and values:
        /// {allowed_values: "E3" allowed_values: "E4"}
        /// The accepted values at `organizations/foo` are `E1`, `E2`.
        /// The accepted values at `projects/bar` are `E3`, and `E4`.
        ///
        /// Example 2 (inherited values):
        /// `organizations/foo` has a `Policy` with values:
        /// {allowed_values: "E1" allowed_values:"E2"}
        /// `projects/bar` has a `Policy` with values:
        /// {value: "E3" value: "E4" inherit_from_parent: true}
        /// The accepted values at `organizations/foo` are `E1`, `E2`.
        /// The accepted values at `projects/bar` are `E1`, `E2`, `E3`, and `E4`.
        ///
        /// Example 3 (inheriting both allowed and denied values):
        /// `organizations/foo` has a `Policy` with values:
        /// {allowed_values: "E1" allowed_values: "E2"}
        /// `projects/bar` has a `Policy` with:
        /// {denied_values: "E1"}
        /// The accepted values at `organizations/foo` are `E1`, `E2`.
        /// The value accepted at `projects/bar` is `E2`.
        ///
        /// Example 4 (RestoreDefault):
        /// `organizations/foo` has a `Policy` with values:
        /// {allowed_values: "E1" allowed_values:"E2"}
        /// `projects/bar` has a `Policy` with values:
        /// {RestoreDefault: {}}
        /// The accepted values at `organizations/foo` are `E1`, `E2`.
        /// The accepted values at `projects/bar` are either all or none depending on
        /// the value of `constraint_default` (if `ALLOW`, all; if
        /// `DENY`, none).
        ///
        /// Example 5 (no policy inherits parent policy):
        /// `organizations/foo` has no `Policy` set.
        /// `projects/bar` has no `Policy` set.
        /// The accepted values at both levels are either all or none depending on
        /// the value of `constraint_default` (if `ALLOW`, all; if
        /// `DENY`, none).
        ///
        /// Example 6 (ListConstraint allowing all):
        /// `organizations/foo` has a `Policy` with values:
        /// {allowed_values: "E1" allowed_values: "E2"}
        /// `projects/bar` has a `Policy` with:
        /// {all: ALLOW}
        /// The accepted values at `organizations/foo` are `E1`, E2`.
        /// Any value is accepted at `projects/bar`.
        ///
        /// Example 7 (ListConstraint allowing none):
        /// `organizations/foo` has a `Policy` with values:
        /// {allowed_values: "E1" allowed_values: "E2"}
        /// `projects/bar` has a `Policy` with:
        /// {all: DENY}
        /// The accepted values at `organizations/foo` are `E1`, E2`.
        /// No value is accepted at `projects/bar`.
        ///
        /// Example 10 (allowed and denied subtrees of Resource Manager hierarchy):
        /// Given the following resource hierarchy
        /// O1->{F1, F2}; F1->{P1}; F2->{P2, P3},
        /// `organizations/foo` has a `Policy` with values:
        /// {allowed_values: "under:organizations/O1"}
        /// `projects/bar` has a `Policy` with:
        /// {allowed_values: "under:projects/P3"}
        /// {denied_values: "under:folders/F2"}
        /// The accepted values at `organizations/foo` are `organizations/O1`,
        /// `folders/F1`, `folders/F2`, `projects/P1`, `projects/P2`,
        /// `projects/P3`.
        /// The accepted values at `projects/bar` are `organizations/O1`,
        /// `folders/F1`, `projects/P1`.
        pub inherit_from_parent: bool,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl ListPolicy {
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [allowed_values][crate::model::policy::ListPolicy::allowed_values].
        pub fn set_allowed_values<T, V>(mut self, v: T) -> Self
        where
            T: std::iter::IntoIterator<Item = V>,
            V: std::convert::Into<std::string::String>,
        {
            use std::iter::Iterator;
            self.allowed_values = v.into_iter().map(|i| i.into()).collect();
            self
        }

        /// Sets the value of [denied_values][crate::model::policy::ListPolicy::denied_values].
        pub fn set_denied_values<T, V>(mut self, v: T) -> Self
        where
            T: std::iter::IntoIterator<Item = V>,
            V: std::convert::Into<std::string::String>,
        {
            use std::iter::Iterator;
            self.denied_values = v.into_iter().map(|i| i.into()).collect();
            self
        }

        /// Sets the value of [all_values][crate::model::policy::ListPolicy::all_values].
        pub fn set_all_values<
            T: std::convert::Into<crate::model::policy::list_policy::AllValues>,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.all_values = v.into();
            self
        }

        /// Sets the value of [suggested_value][crate::model::policy::ListPolicy::suggested_value].
        pub fn set_suggested_value<T: std::convert::Into<std::string::String>>(
            mut self,
            v: T,
        ) -> Self {
            self.suggested_value = v.into();
            self
        }

        /// Sets the value of [inherit_from_parent][crate::model::policy::ListPolicy::inherit_from_parent].
        pub fn set_inherit_from_parent<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
            self.inherit_from_parent = v.into();
            self
        }
    }

    impl wkt::message::Message for ListPolicy {
        fn typename() -> &'static str {
            "type.googleapis.com/google.cloud.orgpolicy.v1.Policy.ListPolicy"
        }
    }

    /// Defines additional types related to [ListPolicy].
    pub mod list_policy {
        #[allow(unused_imports)]
        use super::*;

        /// This enum can be used to set `Policies` that apply to all possible
        /// configuration values rather than specific values in `allowed_values` or
        /// `denied_values`.
        ///
        /// Settting this to `ALLOW` will mean this `Policy` allows all values.
        /// Similarly, setting it to `DENY` will mean no values are allowed. If
        /// set to either `ALLOW` or `DENY,  `allowed_values` and `denied_values`
        /// must be unset. Setting this to `ALL_VALUES_UNSPECIFIED` allows for
        /// setting `allowed_values` and `denied_values`.
        ///
        /// # Working with unknown values
        ///
        /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
        /// additional enum variants at any time. Adding new variants is not considered
        /// a breaking change. Applications should write their code in anticipation of:
        ///
        /// - New values appearing in future releases of the client library, **and**
        /// - New values received dynamically, without application changes.
        ///
        /// Please consult the [Working with enums] section in the user guide for some
        /// guidelines.
        ///
        /// [Working with enums]: https://google-cloud-rust.github.io/working_with_enums.html
        #[derive(Clone, Debug, PartialEq)]
        #[non_exhaustive]
        pub enum AllValues {
            /// Indicates that allowed_values or denied_values must be set.
            Unspecified,
            /// A policy with this set allows all values.
            Allow,
            /// A policy with this set denies all values.
            Deny,
            /// If set, the enum was initialized with an unknown value.
            ///
            /// Applications can examine the value using [AllValues::value] or
            /// [AllValues::name].
            UnknownValue(all_values::UnknownValue),
        }

        #[doc(hidden)]
        pub mod all_values {
            #[allow(unused_imports)]
            use super::*;
            #[derive(Clone, Debug, PartialEq)]
            pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
        }

        impl AllValues {
            /// Gets the enum value.
            ///
            /// Returns `None` if the enum contains an unknown value deserialized from
            /// the string representation of enums.
            pub fn value(&self) -> std::option::Option<i32> {
                match self {
                    Self::Unspecified => std::option::Option::Some(0),
                    Self::Allow => std::option::Option::Some(1),
                    Self::Deny => std::option::Option::Some(2),
                    Self::UnknownValue(u) => u.0.value(),
                }
            }

            /// Gets the enum value as a string.
            ///
            /// Returns `None` if the enum contains an unknown value deserialized from
            /// the integer representation of enums.
            pub fn name(&self) -> std::option::Option<&str> {
                match self {
                    Self::Unspecified => std::option::Option::Some("ALL_VALUES_UNSPECIFIED"),
                    Self::Allow => std::option::Option::Some("ALLOW"),
                    Self::Deny => std::option::Option::Some("DENY"),
                    Self::UnknownValue(u) => u.0.name(),
                }
            }
        }

        impl std::default::Default for AllValues {
            fn default() -> Self {
                use std::convert::From;
                Self::from(0)
            }
        }

        impl std::fmt::Display for AllValues {
            fn fmt(
                &self,
                f: &mut std::fmt::Formatter<'_>,
            ) -> std::result::Result<(), std::fmt::Error> {
                wkt::internal::display_enum(f, self.name(), self.value())
            }
        }

        impl std::convert::From<i32> for AllValues {
            fn from(value: i32) -> Self {
                match value {
                    0 => Self::Unspecified,
                    1 => Self::Allow,
                    2 => Self::Deny,
                    _ => Self::UnknownValue(all_values::UnknownValue(
                        wkt::internal::UnknownEnumValue::Integer(value),
                    )),
                }
            }
        }

        impl std::convert::From<&str> for AllValues {
            fn from(value: &str) -> Self {
                use std::string::ToString;
                match value {
                    "ALL_VALUES_UNSPECIFIED" => Self::Unspecified,
                    "ALLOW" => Self::Allow,
                    "DENY" => Self::Deny,
                    _ => Self::UnknownValue(all_values::UnknownValue(
                        wkt::internal::UnknownEnumValue::String(value.to_string()),
                    )),
                }
            }
        }

        impl serde::ser::Serialize for AllValues {
            fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
            where
                S: serde::Serializer,
            {
                match self {
                    Self::Unspecified => serializer.serialize_i32(0),
                    Self::Allow => serializer.serialize_i32(1),
                    Self::Deny => serializer.serialize_i32(2),
                    Self::UnknownValue(u) => u.0.serialize(serializer),
                }
            }
        }

        impl<'de> serde::de::Deserialize<'de> for AllValues {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                deserializer.deserialize_any(wkt::internal::EnumVisitor::<AllValues>::new(
                    ".google.cloud.orgpolicy.v1.Policy.ListPolicy.AllValues",
                ))
            }
        }
    }

    /// Used in `policy_type` to specify how `boolean_policy` will behave at this
    /// resource.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct BooleanPolicy {
        /// If `true`, then the `Policy` is enforced. If `false`, then any
        /// configuration is acceptable.
        ///
        /// Suppose you have a `Constraint`
        /// `constraints/compute.disableSerialPortAccess` with `constraint_default`
        /// set to `ALLOW`. A `Policy` for that `Constraint` exhibits the following
        /// behavior:
        ///
        /// - If the `Policy` at this resource has enforced set to `false`, serial
        ///   port connection attempts will be allowed.
        /// - If the `Policy` at this resource has enforced set to `true`, serial
        ///   port connection attempts will be refused.
        /// - If the `Policy` at this resource is `RestoreDefault`, serial port
        ///   connection attempts will be allowed.
        /// - If no `Policy` is set at this resource or anywhere higher in the
        ///   resource hierarchy, serial port connection attempts will be allowed.
        /// - If no `Policy` is set at this resource, but one exists higher in the
        ///   resource hierarchy, the behavior is as if the`Policy` were set at
        ///   this resource.
        ///
        /// The following examples demonstrate the different possible layerings:
        ///
        /// Example 1 (nearest `Constraint` wins):
        /// `organizations/foo` has a `Policy` with:
        /// {enforced: false}
        /// `projects/bar` has no `Policy` set.
        /// The constraint at `projects/bar` and `organizations/foo` will not be
        /// enforced.
        ///
        /// Example 2 (enforcement gets replaced):
        /// `organizations/foo` has a `Policy` with:
        /// {enforced: false}
        /// `projects/bar` has a `Policy` with:
        /// {enforced: true}
        /// The constraint at `organizations/foo` is not enforced.
        /// The constraint at `projects/bar` is enforced.
        ///
        /// Example 3 (RestoreDefault):
        /// `organizations/foo` has a `Policy` with:
        /// {enforced: true}
        /// `projects/bar` has a `Policy` with:
        /// {RestoreDefault: {}}
        /// The constraint at `organizations/foo` is enforced.
        /// The constraint at `projects/bar` is not enforced, because
        /// `constraint_default` for the `Constraint` is `ALLOW`.
        pub enforced: bool,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl BooleanPolicy {
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [enforced][crate::model::policy::BooleanPolicy::enforced].
        pub fn set_enforced<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
            self.enforced = v.into();
            self
        }
    }

    impl wkt::message::Message for BooleanPolicy {
        fn typename() -> &'static str {
            "type.googleapis.com/google.cloud.orgpolicy.v1.Policy.BooleanPolicy"
        }
    }

    /// Ignores policies set above this resource and restores the
    /// `constraint_default` enforcement behavior of the specific `Constraint` at
    /// this resource.
    ///
    /// Suppose that `constraint_default` is set to `ALLOW` for the
    /// `Constraint` `constraints/serviceuser.services`. Suppose that organization
    /// foo.com sets a `Policy` at their Organization resource node that restricts
    /// the allowed service activations to deny all service activations. They
    /// could then set a `Policy` with the `policy_type` `restore_default` on
    /// several experimental projects, restoring the `constraint_default`
    /// enforcement of the `Constraint` for only those projects, allowing those
    /// projects to have all services activated.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct RestoreDefault {
        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl RestoreDefault {
        pub fn new() -> Self {
            std::default::Default::default()
        }
    }

    impl wkt::message::Message for RestoreDefault {
        fn typename() -> &'static str {
            "type.googleapis.com/google.cloud.orgpolicy.v1.Policy.RestoreDefault"
        }
    }

    /// The field to populate is based on the `constraint_type` value in the
    /// `Constraint`.
    /// `list_constraint` => `list_policy`
    /// `boolean_constraint` => `boolean_policy`
    ///
    /// A `restore_default` message may be used with any `Constraint` type.
    ///
    /// Providing a *_policy that is incompatible with the `constraint_type` will
    /// result in an `invalid_argument` error.
    ///
    /// Attempting to set a `Policy` with a `policy_type` not set will result in an
    /// `invalid_argument` error.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum PolicyType {
        /// List of values either allowed or disallowed.
        ListPolicy(std::boxed::Box<crate::model::policy::ListPolicy>),
        /// For boolean `Constraints`, whether to enforce the `Constraint` or not.
        BooleanPolicy(std::boxed::Box<crate::model::policy::BooleanPolicy>),
        /// Restores the default behavior of the constraint; independent of
        /// `Constraint` type.
        RestoreDefault(std::boxed::Box<crate::model::policy::RestoreDefault>),
    }
}
